Codable保姆级攻略

前语

Codable 是随 Swift 4.0 推出的，旨在取代现有的 NSCoding 协议，支持结构体、枚举和类，能够将 JSON 这种弱数据类型转化成代码中运用的强数据类型。

Codable 是一个协议，同时统筹了 Decodable 和 Encodable 两个协议，假如你界说了一个数据类型遵照了 Codable 协议，其实是遵照了 Decodable 和 Encodable：

typealias Codable = Decodable & Encodable

说白了便是一套转化协议，能够让数据和 Swift 中的数据类型依据某种映射关系进行转化，比方 JSON 转成你 Swift 中自界说的数据类型。

HandyJSON 在 Codable 推出后已经不再进行维护了，而咱们的项目便是依赖于 HandyJSON 来处理 JSON 的序列化和反序列化，所以咱们也需求逐渐迁移到 Codable 以防止一些过错。

运用技巧

1.基本运用

struct Person: Codable {
  let name: String
  let age: Int
}
// 解码
let json = #" {"name":"Tom", "age": 2} "#
let person = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(person) //Person(name: "Tom", age: 2
// 编码
let data0 = try? JSONEncoder().encode(person) 
let dataObject = try? JSONSerialization.jsonObject(with: data0!, options: []) 
print(dataObject ?? "nil") //{ age = 2; name = Tom; }
let data1 = try? JSONSerialization.data(withJSONObject: ["name": person.name, "age": person.age], options: []) 
print(String(data: data1!, encoding: .utf8)!) //{"name":"Tom","age":2}

2.字段映射

struct Person: Codable {
  let name: String
  let age: Int
  let countryName: String
  private enum CodingKeys: String, CodingKey {
    case countryName = "country"
    case name
    case age
  }
}
let json = #" {"name":"Tom", "age": 2, "country": "China"} "#
let person = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(person) //Person(name: "Tom", age: 2, countryName: "China")

在 Swift 4.1 后，JSONDecoder 增加了 keyDecodingStrategy 特点，假如后端运用带下划线的，蛇形命名法，经过将 keyDecodingStrategy 特点的值设置为 convertFromSnakeCase，这样就不需求写额外的代码来处理映射了：

var decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
// 后端 person_name
// 映射为 personName

3.解析枚举值

解析枚举值有个坑便是原本比方你只要三个 case：

enum TestEnum: String {
	case a
	case b
	case c
}

然后服务端某天多加了几个你没有处理的 case，比方加了个 case d，那这样去解析就直接崩掉了，所以咱们需求想办法给不知道的 case 设置一个默认值。具体的完成是这样，增加一个协议：

protocol CodableEnumeration: RawRepresentable, Codable where RawValue: Codable {
  static var defaultCase: Self { get }
}
extension CodableEnumeration {
  init(from decoder: Decoder) throws {
    let container = try decoder.singleValueContainer()
    do {
      let decoded = try container.decode(RawValue.self)
      self = Self.init(rawValue: decoded) ?? Self.defaultCase
    } catch {
      self = Self.defaultCase
    }
  }
}

然后在遇到不知道的 case 时就能够经过让 Enum 遵守 CodableEnumeration ，然后完成 defaultCase 办法来指定一个 case 即可。

/**
{
	"test_enum" : "d"
}
*/
enum TestEnum: String, CodableEnumeration {
  static var defaultCase: TestEnum {
    .a
  }
  case a
  case b
  case c
}
struct Test: Codable {
  var testEnum: TestEnum
  private enum CodingKeys: String, CodingKey {
    case testEnum = "test_enum"
  }
}
let testJson = #" {"test_enum":"d"} "#
let test = try JSONDecoder().decode(Test.self, from: testJson.data(using: .utf8)!)
print(test.testEnum) // a

4.解析嵌套类型

Swift4 支持条件一致性，所以当数组中的每个元素都遵照 Codable 协议，字典中对应的 key 和 value 遵照 Codable 协议，全体目标就遵照 Codable 协议，便是确保你嵌套的类型都遵照 Codable 协议即可。

struct Student: Codable {
  var id: String
  var name: String
  var grade: Int
}
struct Class: Codable {
  var classNumber: String
  var students: [Student]
}
/**
{
	"classNumber": "111",
	"students": [{
		"id": "1",
		"name": "studentA",
		"grade": 1
	}, {
		"id": "2",
		"name": "studentB",
		"grade": 2
	}]
}
*/
let classJson = #"{"classNumber":"111","students":[{"id":"1","name":"studentA","grade":1},{"id":"2","name":"studentB","grade":2}]}"#
let classModel = try JSONDecoder().decode(Class.self, from: classJson.data(using: .utf8)!)
print(classModel)
/** 输出
▿ Class
  - classNumber : "111"
  ▿ students : 2 elements
    ▿ 0 : Student
      - id : "1"
      - name : "studentA"
      - grade : 1
    ▿ 1 : Student
      - id : "2"
      - name : "studentB"
      - grade : 2
*/

5.解析空值，为null时指定默认值

后端的接口回来的数据可能有值也可能是为空的，这个时候能够将特点设置为可选类型：

/**
{
	"name": "xiaoming",
	"age": 18,
	"partner": null
}
*/
struct Person: Codable {
  let name: String
  let age: Int
  let partner: String?
}
let personJson = #"{"name":"xiaoming","age":18,"partner":null}"#
let person = try JSONDecoder().decode(Person.self, from: personJson.data(using: .utf8)!)
print(person) // Person(name: "xiaoming", age: 18, partner: nil)

假如不想运用可选类型，能够重写 init(from decoder: Decoder) throws 办法，来指定一个默认的值：

struct Person: Codable {
  var name: String
  var age: Int
  var partner: String
  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    age = try container.decode(Int.self, forKey: .age)
    name = try container.decode(String.self, forKey: .name)
    partner = try container.decodeIfPresent(String.self, forKey: .partner) ?? ""
  }
}
let personJson = #"{"name":"xiaoming","age":18,"partner":null}"#
let person = try JSONDecoder().decode(Person.self, from: personJson.data(using: .utf8)!)
print(person) // Person(name: "xiaoming", age: 18, partner: "")

现在只要三个特点，假如特点很多，那写起来就非常费事，好在咱们有更好的计划： Annotating properties with default decoding values 简略来说便是经过 @propertyWrapper 来进行优化，在需求默认值的特点上对这个特点进行声明，编译器就能够主动帮助咱们完成赋默认值的操作，当然，这个特点包裹的完成要咱们自己去完成，代码我就直接贴出来，新建个类放到项目中即可：

protocol DecodableDefaultSource {
  associatedtype Value: Decodable
  static var defaultValue: Value { get }
} 
enum DecodableDefault {}
extension DecodableDefault {
  @propertyWrapper
  struct Wrapper<Source: DecodableDefaultSource> {
    typealias Value = Source.Value
    var wrappedValue = Source.defaultValue
  }
}
extension DecodableDefault.Wrapper: Decodable {
  init(from decoder: Decoder) throws {
    let container = try decoder.singleValueContainer()
    wrappedValue = try container.decode(Value.self)
  }
}
extension KeyedDecodingContainer {
  func decode<T>(_ type: DecodableDefault.Wrapper<T>.Type,
         forKey key: Key) throws -> DecodableDefault.Wrapper<T> {
    try decodeIfPresent(type, forKey: key) ?? .init()
  }
}
extension DecodableDefault {
  typealias Source = DecodableDefaultSource
  typealias List = Decodable & ExpressibleByArrayLiteral
  typealias Map = Decodable & ExpressibleByDictionaryLiteral
  enum Sources {
    enum True: Source { static var defaultValue: Bool { true } }
    enum False: Source { static var defaultValue: Bool { false } }
    enum EmptyString: Source { static var defaultValue: String { "" } }
    enum EmptyList<T: List>: Source { static var defaultValue: T { [] } }
    enum EmptyMap<T: Map>: Source { static var defaultValue: T { [:] } }
    enum Zero: Source { static var defaultValue: Int { 0 } }
  }
} 
extension DecodableDefault {
  typealias True = Wrapper<Sources.True>
  typealias False = Wrapper<Sources.False>
  typealias EmptyString = Wrapper<Sources.EmptyString>
  typealias EmptyList<T: List> = Wrapper<Sources.EmptyList<T>>
  typealias EmptyMap<T: Map> = Wrapper<Sources.EmptyMap<T>>
  typealias Zero = Wrapper<Sources.Zero>
}
extension DecodableDefault.Wrapper: Equatable where Value: Equatable {}
extension DecodableDefault.Wrapper: Hashable where Value: Hashable {}
extension DecodableDefault.Wrapper: Encodable where Value: Encodable {
  func encode(to encoder: Encoder) throws {
    var container = encoder.singleValueContainer()
    try container.encode(wrappedValue)
  }
}

假如需求增加更多的默认值，在 Sources 中增加即可，上面的 Zero 便是额外加的，能够验证一下：

/**
{
	"name":null,
	"money":null,
	"skills":null,
	"teachers":null
}
*/
struct Person: Codable {
  @DecodableDefault.EmptyString var name: String
  @DecodableDefault.Zero var money: Int
  @DecodableDefault.EmptyList var skills: [String]
  @DecodableDefault.EmptyList var teachers: [Teacher]
} 
struct Teacher: Codable {
  @DecodableDefault.EmptyString var name: String
} 
let personJson = #"{"name":null,"money":null,"skills":null,"teachers":null}"#
let person = try JSONDecoder().decode(Person.self, from: personJson.data(using: .utf8)!)
print(person)
/** 输出
▿ Person
 ▿ _name : Wrapper<EmptyString>
  - wrappedValue : ""
 ▿ _money : Wrapper<Zero>
  - wrappedValue : 0
 ▿ _skills : Wrapper<EmptyList<Array<String>>>
  - wrappedValue : 0 elements
 ▿ _teachers : Wrapper<EmptyList<Array<Teacher>>>
  - wrappedValue : 0 elements
*/

6.编码

取 5 中的 person，对它进行编码，并输出字符串或转成对应的数据格式：

// 字符串
do {
  let jsonData = try JSONEncoder().encode(person)
  let jsonString = String(decoding: jsonData, as: UTF8.self)
  print(jsonString) // {"money":0,"teachers":[],"name":"","skills":[]}
} catch {
  print(error.localizedDescription)
}
// 字典
do {
  let jsonData = try JSONEncoder().encode(person)
  let jsonObject = try JSONSerialization.jsonObject(with: jsonData) as? [String : Any]
  print(jsonObject ?? "null")
} catch {
  print(error.localizedDescription)
}

小结

大约常用的操作便是这些，运用起来仍是很方便的，HandyJSON 是依赖于 Swift 的 Runtime 源码揣度内存规矩，假如规矩改变，那么 HandyJSON 就不管用了，而 HandyJSON 现在也不再进行维护，所以在规矩没有改变之前，咱们需求逐渐弃用 HandyJSON 改用原生的 Codable。

参阅

Annotating properties with default decoding values

Encoding and Decoding Custom Types

Codable保姆级攻略

前语

运用技巧

1.基本运用

2.字段映射

3.解析枚举值

4.解析嵌套类型

5.解析空值，为null时指定默认值

6.编码

小结

参阅

更多文章

评估基准在人工智能研究中的重要性

Nop入门：动态SQL管理

Android gralde 脚本迁移到 Kotlin DSL

AST-GREP：基于语法和语义的代码搜索与替换，你需要了解一下！